home *** CD-ROM | disk | FTP | other *** search
/ CD Ware Multimedia 1995 May / cd Ware (Juegos) Epimundo.iso / DOS / C / BFILE.ZIP / BFILE.H < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-11  |  5.0 KB  |  150 lines
  1. /*
  2.  
  3.       bfile.h
  4.       Btrieve class for Borland C++
  5.       09/06/91
  6.  
  7.       Douglas J. Reilly
  8.       Access Microsystems Inc.
  9.       404 Midstreams Road
  10.       Brick, New Jersey  08724
  11.       (908) 892-2683
  12.       CompuServe 74040,607
  13.  
  14.       Comments?  Questions?  Suggestions?
  15.       Have a paying C/C++ programming job you need done?
  16.       Give me a call.
  17.  
  18.       Released into the public domain.  Do with it as you see fit, but
  19.       if you do anything really neat with it, let me know...
  20.  
  21. 10/15/91  DR  Make len default to 0 in constructor, and then set it from
  22.                  open return.
  23.               Set newmode in open() call to -99 by default, ensures
  24.                  that we realize that no mode was sent.
  25. 11/11/91  DR  Multiple fixes and changes to better handle variable length
  26.                  records.
  27.               Add clone_file() to public interface.
  28. */
  29.  
  30. #ifndef BFILE_H
  31. #define BFILE_H
  32. #include "btrieve.h"
  33. extern "C" {
  34. int BTRV(int ,char *,char *,int *,char *,int );
  35. }
  36.  
  37. class bfile {
  38.    char pos_blk[128];        // position block
  39.    char fname[64];           // physical file name
  40.    char logical_name[10];    // logical file name (not used yet)
  41.    int  mode;                // open mode
  42.    int  file_flag;           // flag from STAT call.
  43.    int  fixed_len;           // The non-variable length.
  44.    int  rec_len;             // record length, i.e. higher than above for
  45.                              //    variable lenght records.
  46.                              //    This is == to above UNLESS you pass
  47.                              //    a length to constructor.  For variable
  48.                              //    length records, you MUST pass a length
  49.                              //    that is the upper limit you expect.
  50.    int  last_rec_len;        // most recent returned len
  51.    int  key_num;             // current key number
  52.    int  num_keys;            // number of keys in file
  53.    int  status;              // error status
  54.    int  opened;              // opened flag, not really essential because data
  55.                              //   seemed like it was as natural a flag
  56.                              //   as possible, since we don't want to write
  57.                              //   data to null.
  58.    char *data;               // The data, of course...
  59.    char owner[60];           // owner of the file, used for secured files.
  60. public:
  61.   // file name, lenght, owner, and open mode
  62.   // Note that constructor opens file, destructor closes.
  63.    bfile(char *name,int len=0,char *towner=0,int newmode=0);
  64.    ~bfile();
  65.   // Close file, free up data pointer above.
  66.    int  close();
  67.   // Open, really SB reopen I guess since only useful after close...
  68.    int  open(int newmode=-99);
  69.   // Gets a record.  Uses key 0 unless you set key number (below).
  70.    int  get_rec(char *keystr,int op=B_GET_EQ);
  71.   // Self explanatory...
  72.    void set_key_num(int key=0)
  73.         {
  74.           // sanity check...
  75.            if ( key<num_keys )
  76.            {
  77.               key_num=key;
  78.            }
  79.         }
  80.    int  get_key_num() { return key_num; }
  81.    int  get_key_len(int key_num=-1);
  82.   // Get the number of keys allowed.
  83.    int  get_num_keys() { return num_keys; }
  84.   // take newdata and copy it into the data element.
  85.    int  set_data(char *newdata)
  86.         {
  87.            if ( data!=NULL )
  88.            {
  89.               memcpy(data,newdata,rec_len);
  90.               return(1);
  91.            }
  92.            return(0);
  93.         }
  94.   // return pointer to data.
  95.    char *get_data(int *last_len=0)
  96.         {
  97.            if ( last_len!=0 )
  98.            {
  99.               *last_len=last_rec_len;
  100.            }
  101.            return data;
  102.         }
  103.   // return pointer to COPY data.
  104.    char *dup_data()
  105.         {
  106.            char *datacopy=0;
  107.            if ( opened && data!=0 )
  108.            {
  109.               datacopy=new char[rec_len];
  110.               memset(datacopy,EOS,rec_len);
  111.               if ( datacopy!=0 )
  112.               {
  113.                  memcpy(datacopy,data,rec_len);
  114.               }
  115.            }
  116.            return datacopy;
  117.         }
  118.   // Insert or update record.  could make seperate functions to force one
  119.   //   or the other.  I prefer this.
  120.    int  put_rec(char *keystr,int tlen=0);
  121.   // self explanatory...
  122.    int  del_rec(char *keystr);
  123.   // allow user to get status after operation.
  124.    int  get_status(){ return status; }
  125.   // gets a full FIL_SPEC record (see btrieve.h)
  126.    void get_bstat(struct FIL_SPEC *);
  127.   // returns rec_len private element.
  128.    int  get_len() { return rec_len; }
  129.   // returns last_rec_len private element.
  130.    int  get_last_len() { return last_rec_len; }
  131.    int  get_pos(char *buf)
  132.    {
  133.       int tlen=4;
  134.       char temp[256];
  135.       status=BTRV(B_GET_POS,pos_blk,buf,&tlen,temp,key_num);
  136.       return(status);
  137.    }
  138.    int set_pos(char *buf,char *keystr=0);
  139.    int get_fname(char *tstr)
  140.    {
  141.       if ( tstr!=0 )
  142.       {
  143.          strcpy(tstr,fname);
  144.       }
  145.       return(tstr!=0);
  146.    }
  147.    int clone_file(char *destfname,int overwrite=1);
  148. };
  149. #endif
  150.